#include "colorpicker.h"
#include "ui_colorpicker.h"
#include <iostream>

using namespace std;

ColorPicker::ColorPicker(QRgb couleur, WidgetCouleur *parent) :
    QDialog((QWidget*) parent),
    ui(new Ui::ColorPicker)
{
    wc  = parent;


    ui->setupUi(this);
    ui->spinR->setValue(qRed(couleur));
    ui->spinG->setValue(qGreen(couleur));
    ui->spinBl->setValue(qBlue(couleur));

    updateValeurs(kRGB);
}

ColorPicker::~ColorPicker()
{
    delete ui;
}

//////////// CMJK ///////////////////

void ColorPicker::on_spinC_valueChanged(int)
{
    updateValeurs(kCMJK);
}

void ColorPicker::on_spinM_valueChanged(int)
{
    updateValeurs(kCMJK);
}

void ColorPicker::on_spinJ_valueChanged(int)
{
    updateValeurs(kCMJK);
}

void ColorPicker::on_spinK_valueChanged(int)
{
    updateValeurs(kCMJK);
}



////////////// RGB ////////////

void ColorPicker::on_spinR_valueChanged(int)
{
    updateValeurs(kRGB);
}

void ColorPicker::on_spinG_valueChanged(int)
{
    updateValeurs(kRGB);
}

void ColorPicker::on_spinBl_valueChanged(int)
{
    updateValeurs(kRGB);
}

////////////// HSB /////////////////////////

void ColorPicker::on_spinH_valueChanged(int)
{
    updateValeurs(kHSB);
}

void ColorPicker::on_spinS_valueChanged(int)
{
    updateValeurs(kHSB);
}

void ColorPicker::on_spinBr_valueChanged(int)
{
    updateValeurs(kHSB);
}

/////////////// YUV /////////////////////

void ColorPicker::on_spinY_valueChanged(int)
{
    updateValeurs(kYUV);
}

void ColorPicker::on_spinU_valueChanged(int)
{
    updateValeurs(kYUV);
}

void ColorPicker::on_spinV_valueChanged(int)
{
    updateValeurs(kYUV);
}


void ColorPicker::updateValeurs(const int id) {
    //cout << "id " << id << endl;
    if( id == kRGB) {

        couleur= QColor(ui->spinR->value(), ui->spinG->value(), ui->spinBl->value()) ;
        QString bg =QString("background:") + couleur.name();
        ui->widget->setStyleSheet(bg);
        ui->lineEdit->setText(couleur.name());

        updateCMJK(couleur);
        updateHSB(couleur);

    } else if ( id == kCMJK) {
        int c = (ui->spinC->value()*255)/100;
        int m = (ui->spinM->value()*255)/100;
        int j = (ui->spinJ->value()*255)/100;
        int k = (ui->spinK->value()*255)/100;
        couleur = QColor::fromCmyk(c,m,j,k);
        ui->lineEdit->setText(couleur.name());

        updateRGB(couleur);
        updateHSB(couleur);
        updateYUV(couleur);

    } else if ( id == kHSB) {
        int h = (ui->spinH->value());
        int s = (ui->spinS->value()*255)/100;
        int b = (ui->spinS->value()*255)/100;

        couleur = QColor::fromHsv(h,s,b);

        updateCMJK(couleur);
        updateRGB(couleur);
        updateYUV(couleur);

    } else if (id == kYUV ) {

        double y = ui->spinY->value();
        double u = ui->spinU->value();
        double v = ui->spinV->value();

        int R = (int) (y + 1.140*v);
        int G = (int) (y - 0.395*u - 0.581*v);
        int B = (int) (y + 2.032*u);

        couleur = QColor(R,G,B);

    } else if (id == kHex) {
        QColor couleur(ui->lineEdit->text());

        updateRGB(couleur);
        updateCMJK(couleur);
        updateHSB(couleur);
        updateYUV(couleur);

    } else {
        cerr << "ERREUR COLOR PICKER" << endl;
    }

    ui->lineEdit->blockSignals(true);

    QString bg =QString("background:") + couleur.name();
    //cout << bg.toStdString() << endl;
    ui->widget->setStyleSheet(bg);
    ui->lineEdit->blockSignals(false);

    wc->changeCouleur(qRgb(couleur.red(),couleur.green(),couleur.blue()));
}

void ColorPicker::updateCMJK(QColor couleur) {

    ui->spinC->blockSignals(true);
    ui->spinM->blockSignals(true);
    ui->spinJ->blockSignals(true);
    ui->spinK->blockSignals(true);

    int c,m,j,k; // sont renvoyé dans [0-255] => à passer en [0-100]
    couleur.getCmyk(&c,&m,&j,&k);

    //cout << c << " " << couleur.magentaF() << "/" << couleur.magenta() << " " << j << " " << k << endl;

    ui->spinC->setValue((c*100)/255);
    ui->spinM->setValue((m*100)/255);
    ui->spinJ->setValue((j*100)/255);
    ui->spinK->setValue((k*100)/255);

    ui->spinC->blockSignals(false);
    ui->spinM->blockSignals(false);
    ui->spinJ->blockSignals(false);
    ui->spinK->blockSignals(false);

}

void ColorPicker::updateRGB(QColor couleur) {
    ui->spinR->blockSignals(true);
    ui->spinG->blockSignals(true);
    ui->spinBl->blockSignals(true);

    ui->spinR->setValue(couleur.red());
    ui->spinG->setValue(couleur.green());
    ui->spinBl->setValue(couleur.blue());

    ui->spinR->blockSignals(false);
    ui->spinG->blockSignals(false);
    ui->spinBl->blockSignals(false);
}

void ColorPicker::updateHSB(QColor couleur) {
    int h,s,b;
    couleur.getHsv(&h,&s,&b);

    ui->spinH->blockSignals(true);
    ui->spinS->blockSignals(true);
    ui->spinBr->blockSignals(true);

    ui->spinH->setValue(h);
    ui->spinS->setValue((s*100)/255);
    ui->spinBr->setValue((b*100)/255);

    ui->spinH->blockSignals(false);
    ui->spinS->blockSignals(false);
    ui->spinBr->blockSignals(false);
}

void ColorPicker::updateYUV(QColor couleur) {

    ui->spinY->blockSignals(true);
    ui->spinU->blockSignals(true);
    ui->spinV->blockSignals(true);

    double Y = (0.299* (double) couleur.red()
                + 0.587* (double) couleur.green()
                + 0.114* (double) couleur.blue());
    double U =  (- 0.147* (double)couleur.red()
                 - 0.289* (double) couleur.green()
                 + 0.436* (double)couleur.blue());
    double V = (0.615*(double) couleur.red()
                - (0.515*(double) couleur.green())
                - (0.100*(double) couleur.blue()));
    ui->spinV->setValue(V);
    ui->spinY->setValue(Y);
    ui->spinU->setValue(U);

    ui->spinY->blockSignals(false);
    ui->spinU->blockSignals(false);
    ui->spinV->blockSignals(false);
}


void ColorPicker::on_lineEdit_textChanged(const QString &arg1)
{
    ui->lineEdit->blockSignals(true);
    if(arg1.size() == 7 && QColor::isValidColor(arg1)) {
        couleur = QColor(arg1);
        updateValeurs(kHex);
    }
    ui->lineEdit->blockSignals(false);

}
